// WebSocket连接管理工具
import { ElMessage } from 'element-plus'
import router from '@/router'

let socket = null
let reconnectTimer = null
let messageCallbacks = []
let reconnectCount = 0
const MAX_RECONNECT_ATTEMPTS = 5
let isConnecting = false

// 创建WebSocket连接
export function createWebSocket(userId) {
  // 立即检查并在登录页面直接返回
  if (isInLoginPage()) {
    console.log('当前在登录页面，不建立WebSocket连接')
    stopReconnect() // 确保停止所有重连
    return
  }
  
  console.log('尝试创建WebSocket连接...')
  
  // 检查WebSocket是否可用
  if (typeof WebSocket === 'undefined') {
    console.error('您的浏览器不支持WebSocket，无法建立连接')
    return
  }
  
  if (socket && socket.readyState === WebSocket.OPEN) {
    console.log('WebSocket已连接')
    return
  }
  
  // 避免重复连接
  if (isConnecting) {
    console.log('WebSocket正在连接中...')
    return
  }
  
  isConnecting = true
  
  // 关闭之前的连接
  if (socket) {
    socket.close()
    socket = null
  }
  
  // 获取token
  const token = localStorage.getItem('token')
  if (!token) {
    console.error('未找到token，无法建立WebSocket连接')
    isConnecting = false
    return
  }
  
  // WebSocket服务器地址
  const wsUrl = `ws://10.26.12.190:8800/websocket/ws/chat/${userId}`
  console.log('连接到WebSocket服务器：', wsUrl)
  
  try {
    socket = new WebSocket(wsUrl)
    
    socket.onopen = () => {
      console.log('WebSocket连接已建立')
      stopReconnect() // 清除重连并重置计数器
      isConnecting = false
    }
    
    socket.onmessage = (event) => {
      console.log('收到消息：', event.data)
      try {
        // 尝试解析JSON，如果失败则作为字符串处理
        let data;
        try {
          data = JSON.parse(event.data);
        } catch (parseError) {
          // 如果不是有效的JSON，则直接使用字符串
          data = event.data;
        }
        
        // 触发所有注册的消息回调
        messageCallbacks.forEach(callback => callback(data))
      } catch (error) {
        console.error('处理消息失败：', error)
      }
    }
    
    socket.onclose = (event) => {
      console.log('WebSocket连接已关闭', event.code, event.reason)
      isConnecting = false
      
      // 如果在登录页，不要重连
      if (isInLoginPage()) {
        console.log('在登录页面，不进行重连')
        stopReconnect()
        return
      }
      
      startReconnect(userId)
    }
    
    socket.onerror = (error) => {
      console.error('WebSocket发生错误：', error)
      isConnecting = false
      // 错误通常会触发onclose事件
    }
  } catch (error) {
    console.error('创建WebSocket失败：', error)
    isConnecting = false
    
    // 如果在登录页，不要重连
    if (isInLoginPage()) {
      console.log('在登录页面，不进行重连')
      stopReconnect()
      return
    }
    
    startReconnect(userId)
  }
}

// 关闭WebSocket连接
export function closeWebSocket() {
  if (socket) {
    try {
      // 使用1000代码（正常关闭）和原因信息关闭连接
      // 1000表示正常关闭，这是符合RFC-6455标准的关闭码
      socket.close(1000, "Normal closure by client");
      console.log("WebSocket正常关闭");
    } catch (error) {
      console.error("关闭WebSocket连接时出错:", error);
    } finally {
      socket = null;
    }
  }
  
  stopReconnect();
  isConnecting = false;
}

// 停止重连并重置计数器
function stopReconnect() {
  if (reconnectTimer) {
    clearTimeout(reconnectTimer)
    reconnectTimer = null
  }
  reconnectCount = 0
}

// 检查当前是否在登录页面 (使用更可靠的方法)
function isInLoginPage() {
  try {
    // 1. 首先尝试使用router (更可靠)
    if (router && router.currentRoute && router.currentRoute.value) {
      const routePath = router.currentRoute.value.path
      if (routePath === '/login' || 
          routePath === '/register' || 
          routePath === '/forgot-password') {
        return true
      }
    }
    
    // 2. 备用方法：检查hash (针对hash路由)
    if (window.location.hash) {
      const hash = window.location.hash
      if (hash.includes('#/login') || 
          hash.includes('#/register') || 
          hash.includes('#/forgot-password')) {
        return true
      }
    }
    
    return false
  } catch (error) {
    console.error('检查登录页面出错:', error)
    return false
  }
}

// 发送消息
export function sendMessage(message) {
  if (socket && socket.readyState === WebSocket.OPEN) {
    socket.send(JSON.stringify(message))
    return true
  }
  console.error('WebSocket未连接，消息发送失败')
  return false
}

// 添加消息处理回调
export function addMessageListener(callback) {
  if (typeof callback === 'function' && !messageCallbacks.includes(callback)) {
    messageCallbacks.push(callback)
  }
}

// 移除消息处理回调
export function removeMessageListener(callback) {
  const index = messageCallbacks.indexOf(callback)
  if (index !== -1) {
    messageCallbacks.splice(index, 1)
  }
}

// 开始重连过程
function startReconnect(userId) {
  // 如果在登录页，不要重连
  if (isInLoginPage()) {
    console.log('在登录页面，不进行重连')
    stopReconnect()
    return
  }
  
  // 增加重连次数
  reconnectCount++
  console.log(`WebSocket尝试第${reconnectCount}次重连...`)
  
  // 检查重连次数
  if (reconnectCount >= MAX_RECONNECT_ATTEMPTS) {
    console.error(`WebSocket连接失败，已达到最大重试次数(${MAX_RECONNECT_ATTEMPTS}次)`)
    ElMessage.error('消息服务连接失败，请重新登录')
    
    // 清除登录信息
    localStorage.removeItem('token')
    localStorage.removeItem('userId')
    
    // 重置计数器
    stopReconnect()
    
    // 延迟跳转到登录页面，让用户看到提示消息
    setTimeout(() => {
      router.push('/login')
    }, 1500)
    
    return
  }
  
  reconnectTimer = setTimeout(() => {
    // 再次检查是否在登录页面
    if (isInLoginPage()) {
      console.log('当前在登录页面，取消WebSocket重连')
      stopReconnect()
      return
    }
    
    console.log('尝试重新连接WebSocket...')
    createWebSocket(userId)
  }, 3000) // 3秒后重连
}

// 获取连接状态
export function getConnectionStatus() {
  if (!socket) return 'CLOSED'
  
  switch (socket.readyState) {
    case WebSocket.CONNECTING: return 'CONNECTING'
    case WebSocket.OPEN: return 'OPEN'
    case WebSocket.CLOSING: return 'CLOSING'
    case WebSocket.CLOSED: return 'CLOSED'
    default: return 'UNKNOWN'
  }
} 